/**
 * 给一个树，要求选出点集，使得：任意两点如果连通，则距离不超过1
 * 简单考虑可知，最多只能两个点相连，三点相连则有两点的距离必然为2
 * 因此对树而言，每个点有三种可能：不选，选做子节点，选做父节点
 * 令V、L、U分别对应方案的数量，D是总数，显然有 D = L + U + V
 * 令Lu为u节点选做叶子的方案，则其子节点必须都不选，因此 Lu = PAI{V[sons]}
 * 如果u点不选，则其子节点可以随意，因此 Vu = PAI{D[sons]}
 * 最复杂的是U，因为u点要与其中一个儿子相连，除此之外的其他儿子不选，因此
 *     Uu = SIGMA{Lj * PAI{V[other sons]}}
 * 令 vTotal 是所有son的V之积，则
 *     Uu = vTotal * SIGMA{Lj / Vj}
 * 因此U、V、L、D均可计算。
 */
#include <bits/stdc++.h>
using namespace std;

using llt = long long;
using vi = vector<int>;
using pii = pair<int, int>;

llt const MOD = 998244353LL;

llt qpow(llt a, llt n){
    a = (a % MOD + MOD) % MOD;
    llt ret = 1;
    while(n){
        if(n & 1) ret = ret * a % MOD;
        a = a * a % MOD;
        n >>= 1;
    }
    return ret;
}

llt inv(llt x){return qpow(x, MOD - 2LL);}

int N;
vector<vi> G;

vector<llt> D; // 总数 
vector<llt> L; // 选做叶子
vector<llt> U; // 选有儿子，必然有且只有一个儿子
vector<llt> V; // 不选

void dfs(int u, int p){
    L[u] = 1;
    V[u] = 1;
    U[u] = 0;
    llt vTotal = 1;
    for(auto i : G[u]){
        if(i == p) continue;

        dfs(i, u);

        L[u] = L[u] * V[i] % MOD;
        U[u] = (U[u] + L[i] * inv(V[i]) % MOD) % MOD;
        vTotal = vTotal * V[i] % MOD;
        V[u] = V[u] * D[i] % MOD;
    }
    U[u] = U[u] * vTotal % MOD;
    D[u] = (L[u] + U[u] + V[u]) % MOD;
    return;
}

llt proc(){
    D.assign(N + 1, {});
    L.assign(N + 1, {});
    U.assign(N + 1, {});
    V.assign(N + 1, {});

    dfs(1, 0);
    return D[1];
}

void work(){
    cin >> N;
    G.assign(N + 1, {});
    for(int a,b,i=1;i<N;++i){
        cin >> a >> b;
        G[a].push_back(b);
        G[b].push_back(a);
    } 
    cout << proc() << endl;
    return;
}

int main(){
#ifndef ONLINE_JUDGE
    freopen("z.txt", "r", stdin);
#endif
    ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);

    int nofkase = 1;
    cin >> nofkase;
    while(nofkase--) work();
    return 0;
}
